{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ISubpr_SSsiM"
      },
      "source": [
        "##### Copyright 2020 The TensorFlow Authors.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {},
        "colab_type": "code",
        "id": "3jTMb1dySr3V"
      },
      "outputs": [],
      "source": [
        "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "# you may not use this file except in compliance with the License.\n",
        "# You may obtain a copy of the License at\n",
        "#\n",
        "# https://www.apache.org/licenses/LICENSE-2.0\n",
        "#\n",
        "# Unless required by applicable law or agreed to in writing, software\n",
        "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "# See the License for the specific language governing permissions and\n",
        "# limitations under the License."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "6DWfyNThSziV"
      },
      "source": [
        "# tf.function으로 성능 향상하기\n",
        "\n",
        "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://www.tensorflow.org/guide/function\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />TensorFlow.org 에서 보기</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs-l10n/blob/master/site/ko/guide/function.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />구글 코랩(Google Colab)에서 실행하기</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a target=\"_blank\" href=\"https://github.com/tensorflow/docs-l10n/blob/master/site/ko/guide/function.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />깃헙(GitHub) 소스 보기</a>\n",
        "  </td>\n",
        "  <td>\n",
        "    <a href=\"https://storage.googleapis.com/tensorflow_docs/docs-l10n/site/ko/guide/function.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n",
        "  </td>\n",
        "</table>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Note: 이 문서는 텐서플로 커뮤니티에서 번역했습니다. 커뮤니티 번역 활동의 특성상 정확한 번역과 최신 내용을 반영하기 위해 노력함에도\n",
        "불구하고 [공식 영문 문서](https://www.tensorflow.org/?hl=en)의 내용과 일치하지 않을 수 있습니다.\n",
        "이 번역에 개선할 부분이 있다면\n",
        "[tensorflow/docs-l10n](https://github.com/tensorflow/docs-l10n/) 깃헙 저장소로 풀 리퀘스트를 보내주시기 바랍니다.\n",
        "문서 번역이나 리뷰에 참여하려면\n",
        "[docs-ko@tensorflow.org](https://groups.google.com/a/tensorflow.org/forum/#!forum/docs-ko)로\n",
        "메일을 보내주시기 바랍니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "J122XQYG7W6w"
      },
      "source": [
        "텐서플로 2에서는 즉시 실행(eager execution)이 기본적으로 활성화되어 있습니다.\n",
        "직관적이고 유연한 사용자 인터페이스를 제공하지만 성능과 배포에 비용이 더 듭니다(하나의 연산을 실행할 때는 훨씬 간단하고 빠릅니다).\n",
        "\n",
        "성능을 높이고 이식성이 좋은 모델을 만들려면 `tf.function`을 사용해 그래프로 변환하세요.\n",
        "하지만 조심해야 할 점이 있습니다. `tf.function`은 무조건 속도를 높여주는 마법의 은총알이 아닙니다!\n",
        "\n",
        "이 가이드는 `tf.function`의 이면에 있는 개념을 이해하고 사용법을 완전히 터득할 수 있도록 도울 것입니다.\n",
        "\n",
        "여기서 배울 주요 내용과 권고 사항은 다음과 같습니다:\n",
        "\n",
        "- 즉시 실행 모드에서 디버깅한 다음 `@tf.function`으로 데코레이팅하세요.\n",
        "- 객체 변경(object mutation)이나 리스트 요소 추가 같은 파이썬의 부수 효과에 의존하지 마세요.\n",
        "- `tf.function`은 텐서플로 연산과 가장 잘 동작합니다: 넘파이와 파이썬 호출은 상수로 바뀝니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SjvqpgepHJPd"
      },
      "source": [
        "## 설정"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "otIdN1TS8N7S"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "I0xDjO4SHLUD"
      },
      "source": [
        "에러 출력을 위한 헬퍼 함수를 정의합니다:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "D25apou9IOXa"
      },
      "outputs": [],
      "source": [
        "import traceback\n",
        "import contextlib\n",
        "\n",
        "# 에러 출력을 위한 헬퍼 함수\n",
        "@contextlib.contextmanager\n",
        "def assert_raises(error_class):\n",
        "  try:\n",
        "    yield\n",
        "  except error_class as e:\n",
        "    print('기대하는 예외 발생 \\n  {}:'.format(error_class))\n",
        "    traceback.print_exc(limit=2)\n",
        "  except Exception as e:\n",
        "    raise e\n",
        "  else:\n",
        "    raise Exception('{}를 기대했지만 아무런 에러도 발생되지 않았습니다!'.format(\n",
        "        error_class))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "WPSfepzTHThq"
      },
      "source": [
        "## 기초"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "CNwYTIJ8r56W"
      },
      "source": [
        "`tf.function`으로 정의한 함수는 기본 텐서플로 연산과 같습니다. 즉시 실행 모드로 실행하거나 그레이디언트를 계산할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "SbtT1-Wm70F2"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def add(a, b):\n",
        "  return a + b\n",
        "\n",
        "add(tf.ones([2, 2]), tf.ones([2, 2]))  #  [[2., 2.], [2., 2.]]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "uP-zUelB8DbX"
      },
      "outputs": [],
      "source": [
        "v = tf.Variable(1.0)\n",
        "with tf.GradientTape() as tape:\n",
        "  result = add(v, 1.0)\n",
        "tape.gradient(result, v)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ocWZvqrmHnmX"
      },
      "source": [
        "다른 함수 내부에 사용할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "l5qRjdbBVdU6"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def dense_layer(x, w, b):\n",
        "  return add(tf.matmul(x, w), b)\n",
        "\n",
        "dense_layer(tf.ones([3, 2]), tf.ones([2, 2]), tf.ones([2]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "piBhz7gYsHqU"
      },
      "source": [
        "`tf.function`은 즉시 실행 모드 보다 빠릅니다. 특히 그래프에 작은 연산이 많을 때 그렇습니다. 하지만 (합성곱처럼) 계산량이 많은 연산 몇 개로 이루어진 그래프는 속도 향상이 크지 않습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "zuXt4wRysI03"
      },
      "outputs": [],
      "source": [
        "import timeit\n",
        "conv_layer = tf.keras.layers.Conv2D(100, 3)\n",
        "\n",
        "@tf.function\n",
        "def conv_fn(image):\n",
        "  return conv_layer(image)\n",
        "\n",
        "image = tf.zeros([1, 200, 200, 100])\n",
        "# 워밍 업\n",
        "conv_layer(image); conv_fn(image)\n",
        "print(\"즉시 실행 합성곱:\", timeit.timeit(lambda: conv_layer(image), number=10))\n",
        "print(\"tf.function 합성곱:\", timeit.timeit(lambda: conv_fn(image), number=10))\n",
        "print(\"합성곱 연산 속도에 큰 차이가 없습니다.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "aIKkgr6qdtp4"
      },
      "source": [
        "## 디버깅\n",
        "\n",
        "일반적으로 `tf.function` 보다 즉시 실행 모드가 디버깅하기 쉽습니다.\n",
        "`tf.function`으로 데코레이팅하기 전에 즉시 실행 모드에서 에러가 없는지 확인하세요.\n",
        "디버깅 과정을 위해 `tf.config.run_functions_eagerly(True)`으로 전체 `tf.function`을 비활성화하고 나중에 다시 활성화할 수 있습니다.\n",
        "\n",
        "`tf.function` 함수에서 버그를 추적할 때 다음 팁을 참고하세요:\n",
        "- 파이썬 `print` 함수는 트레이싱(tracing)하는 동안에만 호출되므로 함수가 (재)트레이싱될 때 추적하는데 도움이 됩니다.\n",
        "- `tf.print` 함수는 언제나 실행되므로 실행하는 동안 중간 값을 추적할 때 도움이 됩니다.\n",
        "- `tf.debugging.enable_check_numerics`을 사용하면 쉽게 NaN과 Inf가 발생되는 곳을 추적할 수 있습니다.\n",
        "- `pdb`는 어떻게 트레이싱이 일어나는지 이해하는데 도움이 됩니다(주의: `pdb`는 오토그래프(AutoGraph)가 변환한 소스 코드를 보여줄 것입니다)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uZ4Do2AV80cO"
      },
      "source": [
        "## 트레이싱과 다형성\n",
        "\n",
        "파이썬의 동적 타이핑 덕분에 여러 종류의 매개변수 타입을 사용해 함수를 호출할 수 있고 파이썬은 각기 다르게 수행됩니다.\n",
        "\n",
        "반면 텐서플로 그래프는 정적인 dtype과 shape 차원이 필요합니다. `tf.function`은 올바른 그래프를 생성하기 위해 필요하면 함수를 다시 트레이싱하여 이 문제를 해결합니다. `tf.function`을 사용할 때 발생하는 문제점은 대부분 이런 재트레이싱(retracing) 동작에서 옵니다.\n",
        "\n",
        "다른 종류의 매개변수를 함수를 호출할 때 무슨 일이 일어나는지 확인해 보죠."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "kojmJrgq8U9v"
      },
      "outputs": [],
      "source": [
        "# 함수와 다형성\n",
        "\n",
        "@tf.function\n",
        "def double(a):\n",
        "  print(\"트레이싱:\", a)\n",
        "  return a + a\n",
        "\n",
        "print(double(tf.constant(1)))\n",
        "print()\n",
        "print(double(tf.constant(1.1)))\n",
        "print()\n",
        "print(double(tf.constant(\"a\")))\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4pJqkDR_Q2wz"
      },
      "source": [
        "트레이싱 동작을 제어하기 위해 다음 기법을 사용할 수 있습니다:\n",
        "\n",
        "새로운 `tf.function`을 만듭니다. 별도의 `tf.function` 객체는 트레이싱이 따로 일어납니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "uHp4ousu4DdN"
      },
      "outputs": [],
      "source": [
        "def f():\n",
        "  print('트레이싱!')\n",
        "  tf.print('실행')\n",
        "\n",
        "tf.function(f)()\n",
        "tf.function(f)()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "96IxS2WR37fF"
      },
      "source": [
        "`get_concrete_function` 메서드를 사용해 트레이싱된 특정 함수를 얻을 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "mHg2CGtPQ3Hz"
      },
      "outputs": [],
      "source": [
        "print(\"콘크리트 함수 얻기\")\n",
        "double_strings = double.get_concrete_function(tf.TensorSpec(shape=None, dtype=tf.string))\n",
        "print(\"트레이싱된 함수 실행\")\n",
        "print(double_strings(tf.constant(\"a\")))\n",
        "print(double_strings(a=tf.constant(\"b\")))\n",
        "print(\"콘크리트 함수에 다른 타입을 사용하면 예외가 발생합니다\")\n",
        "with assert_raises(tf.errors.InvalidArgumentError):\n",
        "  double_strings(tf.constant(1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EUtycWJa34TT"
      },
      "source": [
        "`tf.function`에 `input_signature`를 지정하여 트레이싱을 제한할 수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "_BDMIRmu1RGB"
      },
      "outputs": [],
      "source": [
        "@tf.function(input_signature=(tf.TensorSpec(shape=[None], dtype=tf.int32),))\n",
        "def next_collatz(x):\n",
        "  print(\"트레이싱\", x)\n",
        "  return tf.where(x % 2 == 0, x // 2, 3 * x + 1)\n",
        "\n",
        "print(next_collatz(tf.constant([1, 2])))\n",
        "# input_signature에 1-D 텐서를 지정했기 때문에 다음은 실패합니다.\n",
        "with assert_raises(ValueError):\n",
        "  next_collatz(tf.constant([[1, 2], [3, 4]]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Es0WZkLIUSdu"
      },
      "source": [
        "## 언제 다시 트레이싱되나요?\n",
        "\n",
        "다형성을 지원하는 `tf.function`은 트레이싱으로 생성된 콘크리트 함수를 캐싱합니다.\n",
        "이 캐시의 키는 함수의 위치 매개변수(args)와 키워드 매개변수(kwargs)에서 생성된 키의 튜플입니다.\n",
        "`tf.Tensor` 매개변수를 위해 생성된 키는 차원 개수와 타입이 됩니다.\n",
        "파이썬 기본 자료형(정수, 실수, 문자열, 불리언)으로 생성된 키는 해당 변수의 값이 됩니다.\n",
        "그외 다른 파이썬 타입에서 키는 `id()`를 기반으로 합니다.\n",
        "따라서 클래스 메서드는 인스턴스마다 독립적으로 트레이싱됩니다.\n",
        "향후 텐서플로는 파이썬 객체를 안전하게 텐서로 변환하기 위한 고급 캐싱 기능을 제공할 수 있습니다.\n",
        "\n",
        "[콘크리트 함수](../../guide/concrete_function.ipynb)를 참고하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "AY5oiQN0XIyA"
      },
      "source": [
        "## 파이썬 매개변수 vs 텐서 매개변수\n",
        "\n",
        "하이퍼파라미터 조작하고 그래프를 구성하기 위해 파이썬 매개변수가 자주 사용됩니다.\n",
        "예를 들면 `num_layers=10`이나 `training=True`, `nonlinearity='relu'`입니다.\n",
        "파이썬 매개변수가 바뀌면 그래프가 다시 트레이싱됩니다.\n",
        "\n",
        "하지만 파이썬 매개변수가 그래프 구성에 사용되지 않을 수 있습니다.\n",
        "이런 경우 파이썬 값이 변하면 불필요한 재트레이싱을 일으킵니다.\n",
        "예를 들어 다음은 오토그래프가 동적으로 펼치는 훈련 반복 루프입니다.\n",
        "다중 트레이싱이 되었지만 생성된 그래프는 실제로 동일하기 때문에 조금 비효율적입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "uydzR5JYUU8H"
      },
      "outputs": [],
      "source": [
        "def train_one_step():\n",
        "  pass\n",
        "\n",
        "@tf.function\n",
        "def train(num_steps):\n",
        "  print(\"트레이싱 num_steps = {}\".format(num_steps))\n",
        "  for _ in tf.range(num_steps):\n",
        "    train_one_step()\n",
        "\n",
        "train(num_steps=10)\n",
        "train(num_steps=20)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "f6pjnylLUW8P"
      },
      "source": [
        "이를 해결하는 간단한 방법은 생성된 그래프에 영향을 미치지 않도록 매개변수를 `Tensor`로 바꾸는 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "TmL8T-w3UYes"
      },
      "outputs": [],
      "source": [
        "train(num_steps=tf.constant(10))\n",
        "train(num_steps=tf.constant(20))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "129-iRsPS-gY"
      },
      "source": [
        "## `tf.function`의 부수 효과\n",
        "\n",
        "일반적으로 (출력이나 객체 변경 같은) 파이썬 부수 효과(side effect)는 트레이싱 동안에만 일어납니다.\n",
        "어떻게 `tf.function`에서 안정적으로 부수 효과를 일으킬 수 있을까요?\n",
        "\n",
        "일반적인 규칙은 파이썬 부수 효과만을 사용하여 트레이싱을 디버깅하는 것입니다.\n",
        "그외에는 `tf.Variable.assign`, `tf.print`, `tf.summary` 같은 텐서플로 연산이 텐서플로 런타임에 의해 코드가 트레이싱되고 실행되는지 확인하는 가장 좋은 방법입니다.\n",
        "일반적으로 함수 스타일을 사용하는 것이 가장 좋습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "w2sACuZ9TTRk"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def f(x):\n",
        "  print(\"트레이싱\", x)\n",
        "  tf.print(\"실행\", x)\n",
        "\n",
        "f(1)\n",
        "f(1)\n",
        "f(2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "e1I0dPiqTV8H"
      },
      "source": [
        "`tf.function`을 호출할 때마다 파이썬 코드를 실행하려면 `tf.py_function`이 해결책입니다.\n",
        "`tf.py_function`의 단점은 이식성과 성능이 좋지 않고 분산 환경(다중 GPU나 다중 TPU)에서 잘 동작하지 않는다는 것입니다.\n",
        "또한 `tf.py_function`은 미분 가능하도록 그래프를 만들기 때문에 모든 입력/출력을 텐서로 변환합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "7aJD--9qTWmg"
      },
      "outputs": [],
      "source": [
        "external_list = []\n",
        "\n",
        "def side_effect(x):\n",
        "  print('파이썬 부수 효과')\n",
        "  external_list.append(x)\n",
        "\n",
        "@tf.function\n",
        "def f(x):\n",
        "  tf.py_function(side_effect, inp=[x], Tout=[])\n",
        "\n",
        "f(1)\n",
        "f(1)\n",
        "f(1)\n",
        "assert len(external_list) == 3\n",
        "# py_function이 1을 tf.constant(1)로 바꾸기 때문에 .numpy()를 호출해야 합니다.\n",
        "assert external_list[0].numpy() == 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "msTmv-oyUNaf"
      },
      "source": [
        "## 파이썬 상태 주의하기\n",
        "\n",
        "제러네이터와 반복자(iterator) 같은 파이썬의 많은 기능은 상태 추적을 위해 파이썬 런타임에 의존합니다.\n",
        "일반적으로 이런 요소들은 즉시 실행 모드와 같이 동작하지만 \n",
        "트레이싱 동작 때문에 `tf.function` 안에서는 예상밖의 일이 일어날 수 있습니다.\n",
        "\n",
        "예를 하나 들면, 다음 반복자 값을 얻는 것이 파이썬 부수 효과이기 때문에 트레이싱 동안에만 일어납니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "FNPD4unZUedH"
      },
      "outputs": [],
      "source": [
        "external_var = tf.Variable(0)\n",
        "@tf.function\n",
        "def buggy_consume_next(iterator):\n",
        "  external_var.assign_add(next(iterator))\n",
        "  tf.print(\"external_var의 값:\", external_var)\n",
        "\n",
        "iterator = iter([0, 1, 2, 3])\n",
        "buggy_consume_next(iterator)\n",
        "# 다음은 반복자의 다음 값을 추출하지 않고 첫 번째 값을 재사용합니다.\n",
        "buggy_consume_next(iterator)\n",
        "buggy_consume_next(iterator)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "lPr_6mK_AQWL"
      },
      "source": [
        "## 변수\n",
        "\n",
        "코드가 의도한 순서대로 실행되는 것처럼 `tf.function`에서 매우 쉽게 변수를 생성하고 사용할 수 있습니다.\n",
        "하지만 아주 중요한 주의 사항이 있습니다.\n",
        "변수는 즉시 실행 모드와 그래프 모드에서 다르게 동작하는 코드를 만들 수 있습니다.\n",
        "\n",
        "특히 호출마다 새로운 변수를 만들 때 일어납니다.\n",
        "트레이싱 구조 때문에 `tf.function`은 호출마다같은 변수를 재사용합니다.\n",
        "하지만 즉시 실행 모드에서는 호출마다 새로운 변수가 생성됩니다.\n",
        "이런 실수를 방지하기 위해 `tf.function`은 위험한 변수 생성이 감지되면 에러를 발생합니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "Tx0Vvnb_9OB-"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def f(x):\n",
        "  v = tf.Variable(1.0)\n",
        "  v.assign_add(x)\n",
        "  return v\n",
        "\n",
        "with assert_raises(ValueError):\n",
        "  f(1.0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ot8o7PeFIINo"
      },
      "source": [
        "하지만 모호하지 않은 코드는 괜찮습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "DKzNjVg8h4ao"
      },
      "outputs": [],
      "source": [
        "v = tf.Variable(1.0)\n",
        "\n",
        "@tf.function\n",
        "def f(x):\n",
        "  return v.assign_add(x)\n",
        "\n",
        "print(f(1.0))  # 2.0\n",
        "print(f(2.0))  # 4.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KYm6-5GCILXQ"
      },
      "source": [
        "함수가 처음 호출될 때만 변수가 생성되도록 `tf.function` 안에서 변수를 생성할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "HQrG5_kOiKl_"
      },
      "outputs": [],
      "source": [
        "class C:\n",
        "  pass\n",
        "\n",
        "obj = C()\n",
        "obj.v = None\n",
        "\n",
        "@tf.function\n",
        "def g(x):\n",
        "  if obj.v is None:\n",
        "    obj.v = tf.Variable(1.0)\n",
        "  return obj.v.assign_add(x)\n",
        "\n",
        "print(g(1.0))  # 2.0\n",
        "print(g(2.0))  # 4.0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "SDT4oKJaIim8"
      },
      "source": [
        "변수 초기화가 함수 매개변수와 다른 변수 값에 의존할 수 있습니다.\n",
        "올바른 초기화 순서를 찾기 위해 제어 의존성을 생성하는 메서드를 사용할 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "_IOVc1eujMH2"
      },
      "outputs": [],
      "source": [
        "state = []\n",
        "@tf.function\n",
        "def fn(x):\n",
        "  if not state:\n",
        "    state.append(tf.Variable(2.0 * x))\n",
        "    state.append(tf.Variable(state[0] * 3.0))\n",
        "  return state[0] * x * state[1]\n",
        "\n",
        "print(fn(tf.constant(1.0)))\n",
        "print(fn(tf.constant(3.0)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "5f05Vr_YBUCz"
      },
      "source": [
        "## 오토그래프 변환\n",
        "\n",
        "오토그래프(AutoGraph)는 `tf.function`안에 기본으로 활성화되어 있습니다. 파이썬의 즉시 실행 코드를 그래프 호환 텐서플로 연산으로 변환합니다. 여기에는 `if`, `for`, `while` 같은 제어 흐름이 포함됩니다.\n",
        "\n",
        "`tf.cond`와 `tf.while_loop` 같은 텐서플로 연산을 여전히 사용할 수 있지만 파이썬으로 제어 흐름을 작성하는 것이 만들기도 이해하기도 쉽습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "yCQTtTPTW3WF"
      },
      "outputs": [],
      "source": [
        "# 간단한 루프\n",
        "\n",
        "@tf.function\n",
        "def f(x):\n",
        "  while tf.reduce_sum(x) > 1:\n",
        "    tf.print(x)\n",
        "    x = tf.tanh(x)\n",
        "  return x\n",
        "\n",
        "f(tf.random.uniform([5]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "KxwJ8znPI0Cg"
      },
      "source": [
        "관심있다면 오토그래프가 생성한 코드를 확인해 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "jlQD1ffRXJhl"
      },
      "outputs": [],
      "source": [
        "print(tf.autograph.to_code(f.python_function))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "xgKmkrNTZSyz"
      },
      "source": [
        "### 조건문\n",
        "\n",
        "오토그래프는 `if <condition>` 문장을 이와 대등한 `tf.cond` 호출로 변경합니다.\n",
        "이런 대체는 `<condition>`이 텐서일 때 수행됩니다.\n",
        "그렇지 않다면 `if` 문장은 파이썬 조건문으로 실행됩니다.\n",
        "\n",
        "트레이싱하는 동안 파이썬 조건문을 실행하기 때문에 정확히 하나의 조건 분기만 그래프에 추가됩니다.\n",
        "오토그래프가 없다면 이렇게 트레이싱된 그래프는 데이터에 따라 제어 흐름을 바꿀 수 없습니다.\n",
        "\n",
        "`tf.cond`는 조건 분기를 트레이싱하고 그래프에 추가하여 실행시 동적으로 분기를 선택합니다. 트레이싱때문에 의도치 않은 부수 효과가 발생될 수 있습니다. 더 자세한 내용은 [오토그래프 트레이싱 효과](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/control_flow.md#effects-of-the-tracing-process)를 참고하세요."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "BOQl8PMq2Sf3"
      },
      "outputs": [],
      "source": [
        "@tf.function\n",
        "def fizzbuzz(n):\n",
        "  for i in tf.range(1, n + 1):\n",
        "    print('루프 트레이싱')\n",
        "    if i % 15 == 0:\n",
        "      print('fizzbuzz 브랜치 트레이싱')\n",
        "      tf.print('fizzbuzz')\n",
        "    elif i % 3 == 0:\n",
        "      print('fizz 브랜치 트레이싱')\n",
        "      tf.print('fizz')\n",
        "    elif i % 5 == 0:\n",
        "      print('buzz 브랜치 트레이싱')\n",
        "      tf.print('buzz')\n",
        "    else:\n",
        "      print('디폴트 브랜치 트레이싱')\n",
        "      tf.print(i)\n",
        "\n",
        "fizzbuzz(tf.constant(5))\n",
        "fizzbuzz(tf.constant(20))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "4rBO5AQ15HVC"
      },
      "source": [
        "오토그래프가 변환한 if 문장에 대한 추가 제약 사항에 대해서는 [레퍼런스 문서](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/control_flow.md#if-statements)를 참고하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "yho4J0a0ZkQS"
      },
      "source": [
        "### 반복문\n",
        "\n",
        "오토그래프는 일부 `for`와 `while` 문장을 `tf.while_loop`와 같은 동등한 텐서플로 반복 연산으로 바꿉니다.\n",
        "변환되지 않으면 파이썬 반복문으로 `for`와 `while` 반복문이 실행됩니다.\n",
        "\n",
        "이런 대체는 다음과 같은 경우에 일어납니다:\n",
        "\n",
        "- `for x in y`: `y`가 텐서이면 `tf.while_loop`로 변환됩니다. 특별히 `y`가 `tf.data.Dataset`인 경우에는 `tf.data.Dataset` 연산의 조합이 생성됩니다.\n",
        "- `while <condition>`: `<condition>`이 텐서라면 `tf.while_loop`로 변환됩니다.\n",
        "\n",
        "파이썬 반복문이 트레이싱 동안 실행되므로 매 반복마다 `tf.Graph`에 추가적인 연산이 포함됩니다.\n",
        "\n",
        "텐서플로는 반복문 블럭을 트레이싱하여 실행시 얼마나 많은 반복이 수행될지 동적으로 선택합니다. 반복문 블럭은 생성된 `tf.Graph`에 한 번만 포함됩니다.\n",
        "\n",
        "오토그래프가 변환한 `for`와 `while` 문장에 대한 추가 제약 사항에 대해서는 [레퍼런스 문서](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/autograph/g3doc/reference/control_flow.md#while-statements)를 참고하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "sp4rbIdfbM6s"
      },
      "source": [
        "#### 파이썬 데이터로 반복하기\n",
        "\n",
        "흔히 저지르기 쉬운 실수는 `tf.function` 안에서 파이썬이나 넘파이 데이터로 반복하는 것입니다. 트레이싱 과정 동안 반복이 수행되기 때문에 반복마다 `tf.Graph`에 복사된 모델이 추가될 것입니다.\n",
        "\n",
        "`tf.function`으로 전체 훈련 반복을 감싸고 싶다면 안전한 방법은 데이터를 `tf.data.Dataset`으로 감싸서 오토그래프가 동적으로 훈련 반복을 펼치게 하는 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "WGZ19LspbZ27"
      },
      "outputs": [],
      "source": [
        "def measure_graph_size(f, *args):\n",
        "  g = f.get_concrete_function(*args).graph\n",
        "  print(\"{}({})는 그래프에 {}개의 노드를 포함합니다\".format(\n",
        "      f.__name__, ', '.join(map(str, args)), len(g.as_graph_def().node)))\n",
        "\n",
        "@tf.function\n",
        "def train(dataset):\n",
        "  loss = tf.constant(0)\n",
        "  for x, y in dataset:\n",
        "    loss += tf.abs(y - x) # 의미없는 연산\n",
        "  return loss\n",
        "\n",
        "small_data = [(1, 1)] * 3\n",
        "big_data = [(1, 1)] * 10\n",
        "measure_graph_size(train, small_data)\n",
        "measure_graph_size(train, big_data)\n",
        "\n",
        "measure_graph_size(train, tf.data.Dataset.from_generator(\n",
        "    lambda: small_data, (tf.int32, tf.int32)))\n",
        "measure_graph_size(train, tf.data.Dataset.from_generator(\n",
        "    lambda: big_data, (tf.int32, tf.int32)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "JeD2U-yrbfVb"
      },
      "source": [
        "데이터셋으로 파이썬/넘파이 데이터를 감쌀 때 `tf.data.Dataset.from_generator`와 ` tf.data.Dataset.from_tensors`의 차이를 주의하세요.\n",
        "전자는 파이썬에서 데이터를 유지하고 `tf.py_function`으로 데이터를 가져오므로 성능에 영향을 미칠 수 있습니다.\n",
        "후자는 그래프에 있는 하나의 큰 `tf.constant()` 노드로 데이터를 복사하므로 메모리에 영향을 미칠 수 있습니다.\n",
        "\n",
        "`TFRecordDataset`, `CsvDataset` 등으로 파일에서 데이터를 읽는 것이 가장 효율적으로 데이터를 소비하는 방법입니다. 텐서플로는 파이썬을 거치지 않고 비동기적으로 데이터를 적재하고 프리페칭할 수 있기 때문입니다. 조금 더 자세한 정보는 [tf.data guide](../../guide/data)를 참고하세요."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "hyksHW9TCukR"
      },
      "source": [
        "#### 반복하면서 값을 누적하기\n",
        "\n",
        "반복하면서 중간 값을 누적하는 패턴은 자주 있습니다.\n",
        "보통 파이썬 리스트나 딕셔너리에 원소를 추가하는 방식을 사용합니다.\n",
        "하지만 파이썬 부수 효과 때문에 동적으로 펼쳐지는 반복에서는 기대대로 동작하지 않습니다.\n",
        "대신 `tf.TensorArray`를 사용해 동적으로 펼쳐지는 반복에서 결과를 누적하세요."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {},
        "colab_type": "code",
        "id": "HJ3Vb3dXfefN"
      },
      "outputs": [],
      "source": [
        "batch_size = 2\n",
        "seq_len = 3\n",
        "feature_size = 4\n",
        "\n",
        "def rnn_step(inp, state):\n",
        "  return inp + state\n",
        "\n",
        "@tf.function\n",
        "def dynamic_rnn(rnn_step, input_data, initial_state):\n",
        "  # [batch, time, features] -> [time, batch, features]\n",
        "  input_data = tf.transpose(input_data, [1, 0, 2])\n",
        "  max_seq_len = input_data.shape[0]\n",
        "\n",
        "  states = tf.TensorArray(tf.float32, size=max_seq_len)\n",
        "  state = initial_state\n",
        "  for i in tf.range(max_seq_len):\n",
        "    state = rnn_step(input_data[i], state)\n",
        "    states = states.write(i, state)\n",
        "  return tf.transpose(states.stack(), [1, 0, 2])\n",
        "  \n",
        "dynamic_rnn(rnn_step,\n",
        "            tf.random.uniform([batch_size, seq_len, feature_size]),\n",
        "            tf.zeros([batch_size, feature_size]))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "IKyrEY5GVX3M"
      },
      "source": [
        "## 더 읽을 거리\n",
        "\n",
        "`tf.function`을 트레이싱한 후 수행되는 그래프 최적화에 자세히 알고 싶다면 [그래플러(Grappler) 가이드](../../guide/graph_optimization)를 참고하세요. 데이터 파이프라인을 최적화하고 모델 프로파일링 방법에 대해 알고 싶다면 [프로파일러(Profiler) 가이드](../../guide/profiler.md)를 참고하세요."
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "function.ipynb",
      "private_outputs": true,
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
